home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Taifun / Taifun 079 (1988-11-15)(Ossowski, Stefan)(DE)(PD).zip / Taifun 079 (1988-11-15)(Ossowski, Stefan)(DE)(PD).adf / GiroMan / Sources / Giro.c < prev    next >
C/C++ Source or Header  |  1988-08-14  |  41KB  |  2,013 lines
  1. /*     Giro.c 
  2.     -----------------------
  3.     SourceCode für GiroMan V3.00
  4.     Letzte Änderung am 06.03.1988
  5.  
  6. */
  7.  
  8. #include "Data.h"
  9.  
  10.  
  11. /*********************************************************************/
  12.  
  13. VOID _cli_parse(){}
  14. VOID _wb_parse(){}
  15.  
  16. /*********************************************************************/
  17.  
  18. VOID main()
  19. {
  20. VOID Open_Things(),Auswertung();
  21. BOOL Open_Datei(),Load_Index();
  22.  
  23. Open_Things();
  24. Set_Screen_Title(MAINWIND,WORKTITEL);
  25. if(!(Load_Index() && Open_Datei()))
  26.     {
  27.     Disk_Fehler(MainWindow);
  28.     EndProgramm(99);
  29.     }
  30. Auswertung();
  31. EndProgramm(0);
  32. }
  33.  
  34. /*********************************************************************/
  35.  
  36. VOID Open_Things()
  37. {
  38. VOID Make_Graphics();
  39. UCOUNT    i;
  40.  
  41. if(!(IntuitionBase = (struct IntuitionBase*)
  42.          OpenLibrary("intuition.library",NULL)))         EndProgramm(10);
  43. if(!(GfxBase = (struct GfxBase*)
  44.          OpenLibrary("graphics.library",NULL)))             EndProgramm(11);
  45.  
  46. if(AvailMem(MEMF_CHIP)<50000L || AvailMem(MEMF_PUBLIC)<75000L)    EndProgramm(30);
  47. if(!(UndoBuffer=(STRPTR)AllocMem( 50L,MEMF_PUBLIC|MEMF_CLEAR)))    EndProgramm(31);
  48. if(!(TempText = (STRPTR)AllocMem( 50L,MEMF_PUBLIC|MEMF_CLEAR)))    EndProgramm(32);
  49. if(!(TempTextGr=(STRPTR)AllocMem(100L,MEMF_PUBLIC|MEMF_CLEAR)))    EndProgramm(33);
  50.  
  51. for(i=0;i<3;i++)
  52.     {
  53.     if(!(EingabeBuffer[i]=
  54.         (STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR)))    EndProgramm(34);
  55.     EinGadInfo[i].Buffer=EingabeBuffer[i];
  56.     EinGadInfo[i].UndoBuffer=UndoBuffer;
  57.     }
  58. for(i=0;i<3;i++)
  59.     {
  60.     if(!(SuchBuffer[i]=
  61.         (STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR)))    EndProgramm(35);
  62.     SuchInfo[i].Buffer=SuchBuffer[i];
  63.     SuchInfo[i].UndoBuffer=UndoBuffer;
  64.     }
  65. for(i=0;i<3;i++)
  66.     {
  67.     if(!(MonatBuffer[i]=
  68.         (STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR)))    EndProgramm(36);
  69.     MonatInfo[i].Buffer=MonatBuffer[i];
  70.     MonatInfo[i].UndoBuffer=UndoBuffer;
  71.     }
  72. if(!(Window1.Screen = (MainScreen = (struct Screen*) 
  73.          OpenScreen(&Screen1))))                    EndProgramm(12);
  74. if(!(MainWindow = (struct Window*)
  75.     OpenWindow(&Window1)))                    EndProgramm(13);
  76.  
  77. Make_Graphics();
  78. Off_Str_Gadgets();
  79. return;
  80. }
  81.  
  82. /*********************************************************************/
  83.  
  84. VOID Make_Graphics()
  85. {
  86. Main_rp= MainWindow->RPort;
  87. Main_vp= &MainScreen->ViewPort;
  88.  
  89. SetRGB4(Main_vp,GREY,13L,13L,14L);    /* Farbe 0    = hellgrau */    
  90. SetRGB4(Main_vp,BLACK,1L,1L,1L);    /* Farbe 1    = schwarz  */
  91. SetRGB4(Main_vp,RED,12L,1L,0L);        /* Farbe 2    = rot      */
  92. SetRGB4(Main_vp,BLUE, 0L,0L,9L);    /* Farbe 3    = blau     */
  93.  
  94. SetAPen(Main_rp,BLUE);
  95. SetBPen(Main_rp,GREY);
  96. SetDrMd(Main_rp,JAM2);
  97.  
  98. SetMenuStrip(MainWindow,&Menu1);
  99. Menu_Normal(AN);
  100. Menu_Saven(AUS);
  101. PolyDraw(Main_rp,30L,Umrandungen);
  102. return;
  103. }
  104.  
  105. /*********************************************************************/
  106.  
  107. BOOL Load_Index()
  108. {
  109. BOOL Ok = FALSE;
  110.  
  111. if(!(Index=AllocMem(INDEXLENG,MEMF_CLEAR)))    EndProgramm(30);
  112. if((DateiIndex=Open(IndexName,MODE_OLDFILE))
  113. &&(Read(DateiIndex,Index,INDEXLENG) != DISKERROR))
  114.     Ok =TRUE;
  115. if(DateiIndex)
  116.     Close(DateiIndex);
  117. DateiIndex = NULL;
  118. return(Ok);
  119. }
  120.  
  121. /*********************************************************************/
  122.  
  123. BOOL Open_Datei()
  124. {
  125. BOOL Ok = FALSE;
  126.  
  127. if(!(Eintrag=AllocMem(SIZEEINTRAG*20,MEMF_PUBLIC|MEMF_CLEAR)))    EndProgramm(31);
  128. if((HauptDatei=Open(DateiName,MODE_READWRITE))
  129. &&(Seek(HauptDatei,-8L,OFFSET_END) != DISKERROR)
  130. &&(Read(HauptDatei,&DatenAkt,2L) != DISKERROR)
  131. &&(Read(HauptDatei,&AltSaldo,4L) != DISKERROR)
  132. &&(Read(HauptDatei,&NeuVergeben,2L) !=DISKERROR))
  133.     {
  134.     Ok = TRUE;
  135.     Geaendert = FALSE;
  136.     NeuSaldo = AltSaldo;
  137.     NeuDatenAkt = DatenAkt;
  138.     AktIndex = Index+DATENMAX;
  139.     MaxIndex = AktIndex-19;
  140.     PrintIText(Main_rp,&Ueber[2],0L,0L);
  141.     Print(Main_rp,BetrInAsc(AltSaldo),TAB(AltSaldo),240L,FAR(AltSaldo));
  142.     PrintNeuSaldo();
  143.     PrintUntereSeite();
  144.     }
  145. return(Ok);
  146. }
  147.  
  148. /*********************************************************************/
  149.  
  150. VOID Auswertung()
  151. {
  152. VOID    WelchesGadget();
  153. BOOL    Menu();
  154. VOID    Abfrage_Maus();
  155. BOOL    Ende = FALSE;
  156.  
  157. while (Ende == FALSE)
  158.     {
  159.     IDCMP_Abfrage(MainWindow);
  160.     switch (MessClass)
  161.         {
  162.         case GADGETDOWN:
  163.         case GADGETUP:
  164.             WelchesGadget();
  165.             break;
  166.         
  167.         case MENUPICK:
  168.             Ende = Menu();
  169.             break;
  170.  
  171.         case MOUSEBUTTONS:
  172.             Abfrage_Maus();
  173.             break;
  174.         }
  175.     }
  176. return; 
  177. }
  178.  
  179. /*********************************************************************/
  180.  
  181. VOID WelchesGadget()
  182. {
  183. VOID Move_Slider();
  184.  
  185. switch (GadID)
  186.     {
  187.     case 1:  
  188.         Move_Slider();
  189.         break;
  190.     case 2:
  191.         PrintNachOben();
  192.         break;
  193.     case 3:
  194.         PrintNachUnten();
  195.         break;
  196.     }
  197. return;
  198. }
  199.  
  200. /*********************************************************************/
  201.  
  202. VOID Move_Slider()
  203. {
  204. INDEX    *IN;
  205. INDEX    *min = Index+DATENMAX-NeuDatenAkt;
  206. BOOL    Direkt = (MessClass != GADGETUP) ? TRUE : FALSE;
  207.  
  208. do
  209.     {
  210.     if(Direkt)
  211.         {
  212.         if((Message=(struct IntuiMessage*)
  213.             GetMsg(MainWindow->UserPort))!=NULL)
  214.             {    
  215.             MessClass = Message->Class;
  216.             ReplyMsg(Message);
  217.             }
  218.         }
  219.     IN = min+((Slider.VertPot/NeuProp)*20);
  220.     if(IN > MaxIndex)  IN = MaxIndex;
  221.     Setz_VonBis(IN);
  222.     }
  223. while(MessClass != GADGETUP);
  224.  
  225. if(IN != AktIndex)
  226.     {
  227.     if(IN > AktIndex)
  228.         {
  229.         if(Direkt) AktIndex = IN-20;
  230.         PrintNachUnten();
  231.         }
  232.     else
  233.         {
  234.         if(Direkt) AktIndex = IN+20;
  235.         PrintNachOben();
  236.         }
  237.     }    
  238. return;
  239. }
  240.  
  241. /*********************************************************************/
  242.  
  243. BOOL Menu()
  244. {
  245. VOID    Hinzu_Fuegen();
  246. VOID    Aendere_Eintrag();
  247. VOID    Loesche_Eintrag();
  248. VOID    Suchen();
  249. VOID    Neue_Datei();
  250. VOID    Neues_Saldo();
  251. VOID    Finde_Datum();
  252. VOID    Saldo_Suchen();
  253. VOID    Drucken();
  254. VOID    Monats_Daten();
  255. VOID    Monat_Hinzu();
  256. BOOL    Save_All();
  257.  
  258. BOOL Ende=FALSE;
  259.  
  260. if(MENUNUM(MessCode) != MENUNULL)
  261.     switch(MENUNUM(MessCode))
  262.         {
  263.         case 0:                    /* PROGRAMM */
  264.         switch(ITEMNUM(MessCode))
  265.             {
  266.             case 0:                /* Beenden */
  267.             if(Geaendert)
  268.                 {
  269.                 if(Abfr_ReqGr(MainWindow,&ReqText[2],
  270.                             &ReqGad2,NULL))
  271.                     if(!(Ende = Save_All()))
  272.                         Disk_Fehler(MainWindow);
  273.                 }
  274.             else
  275.                 {
  276.                 Ende = TRUE;
  277.                 }
  278.             break;
  279.  
  280.             case 1:
  281.             Abfr_ReqGr(MainWindow,&ReqText[30],&ReqGad1,NULL);
  282.             break;
  283.             }
  284.         break;
  285.         
  286.         case 1:                    /* GIRODATEN */
  287.         switch(ITEMNUM(MessCode))
  288.             {
  289.             case 0:
  290.             Hinzu_Fuegen();
  291.             break;
  292.             
  293.             case 1:
  294.             Suchen();
  295.             break;
  296.  
  297.             case 2:
  298.             if(!(Save_All()))
  299.                 Disk_Fehler(MainWindow);
  300.             break;
  301.             }
  302.         break;        
  303.         
  304.         case 2:                    /* EDITIEREN */
  305.         switch (ITEMNUM(MessCode))
  306.             {
  307.             case 0:
  308.             Drucken();
  309.             break;
  310.  
  311.             case 1:
  312.             Saldo_Suchen();
  313.             break;
  314.  
  315.             case 2:
  316.             Aendere_Eintrag();
  317.             break;
  318.             
  319.             case 3:
  320.             Loesche_Eintrag();
  321.             break;
  322.             }
  323.         break;
  324.         
  325.         case 3:                    /* Anzeige */
  326.         switch (ITEMNUM(MessCode))
  327.             {
  328.             case 0:
  329.             if(AktIndex != (Index+DATENMAX-NeuDatenAkt))
  330.                 {
  331.                 AktIndex = Index + 20;
  332.                 PrintNachOben();
  333.                 }
  334.             else    Beep(MainScreen);
  335.             break;
  336.             
  337.             case 1:
  338.             if(AktIndex != MaxIndex)
  339.                 {
  340.                 AktIndex = MaxIndex - 1;
  341.                 PrintNachUnten();
  342.                 }
  343.             else    Beep(MainScreen);
  344.             break;
  345.  
  346.             case 2:
  347.             if(Abfr_ReqGr(MainWindow,&ReqText[6],
  348.                 &SuchGadget[0],&SuchGadget[0]))
  349.                 {
  350.                 Finde_Datum(SuchBuffer[0]);
  351.                 AktIndex -= 20;
  352.                 PrintNachUnten();
  353.                 }
  354.             break;
  355.             }
  356.         break;
  357.  
  358.         case 4:
  359.         switch (ITEMNUM(MessCode))
  360.             {
  361.             case 0:
  362.             Neue_Datei();
  363.             break;
  364.  
  365.             case 1:
  366.             Neues_Saldo();
  367.             break;
  368.             }
  369.         break;
  370.  
  371.         case 5:                    /* MONATSDATEN */
  372.         switch (ITEMNUM(MessCode))
  373.             {
  374.             case 0:
  375.             Monat_Hinzu();
  376.             break;
  377.  
  378.             case 1:
  379.             Monats_Daten();
  380.             break;
  381.             }
  382.         break;
  383.         }
  384. return(Ende);
  385. }
  386.  
  387. /*********************************************************************/
  388.  
  389. VOID Abfrage_Maus()
  390. {
  391. SHORT Aktiviere_Zeile();
  392.  
  393. if(MessCode != SELECTUP)
  394.     if(!(MainWindow->MouseY > 212
  395.       || MainWindow->MouseY < 33
  396.       || MainWindow->MouseX > 610))
  397.         AktiveZeile = Aktiviere_Zeile((MainWindow->MouseY-33)/9);
  398. return;
  399. }
  400.  
  401. /*********************************************************************/
  402.  
  403. VOID IDCMP_Abfrage(Window)
  404. struct Window *Window;
  405. {
  406. struct Gadget *Gadget;
  407.  
  408. GadID = 0;
  409. Wait(1L<<Window->UserPort->mp_SigBit);
  410. while((Message = (struct IntuiMessage*)
  411.     GetMsg(Window->UserPort)) != NULL)
  412.     {
  413.     MessClass    = Message->Class;
  414.     MessCode     = Message->Code;
  415.     if((MessClass == GADGETUP) || (MessClass == GADGETDOWN))
  416.         {
  417.         Gadget    = (struct Gadget*) Message->IAddress;
  418.         GadID    = Gadget->GadgetID;
  419.         }
  420.  
  421.     ReplyMsg(Message);
  422.     }
  423. return;
  424. }
  425.  
  426. /*********************************************************************/
  427.  
  428. VOID Hinzu_Fuegen()
  429. {
  430. VOID    Loesch_Str_Gadgets();
  431. BOOL    Abfrage_EingabeSchluss(); 
  432. BOOL    EingabeSchluss = FALSE;
  433. USHORT  No = NeuDatenAkt;
  434.  
  435. On_Str_Gadgets();
  436. ActivateGadget(&EingabeGadget[0],MainWindow,NULL);
  437.  
  438. while(EingabeSchluss == FALSE)
  439.     {
  440.     if(NeuDatenAkt < DATENMAX)
  441.         {
  442.         IDCMP_Abfrage(MainWindow);
  443.  
  444.         if(MessClass == GADGETUP)
  445.             {
  446.             switch(GadID)
  447.                 {
  448.                 case 10:
  449.                 EingabeSchluss = Abfrage_EingabeSchluss(0);
  450.                 break;
  451.  
  452.                 case 11:
  453.                 EingabeSchluss = Abfrage_EingabeSchluss(1);
  454.                 break;
  455.  
  456.                 case 12:
  457.                 EingabeSchluss = Abfrage_EingabeSchluss(2);
  458.                 break;
  459.                 }
  460.             }
  461.         }
  462.     else
  463.         {
  464.         Abfr_ReqGr(MainWindow,&ReqText[5],&ReqGad1,NULL);
  465.         EingabeSchluss = TRUE;
  466.         }
  467.     }
  468. Loesch_Str_Gadgets();
  469. Off_Str_Gadgets();
  470. if(No != NeuDatenAkt)
  471.     {
  472.     Menu_Saven(AN);
  473.     Print_And_Sort();
  474.     }
  475. return;
  476. }
  477.  
  478. /*********************************************************************/
  479.  
  480. VOID Suchen()
  481. {
  482. VOID    Zeichne_Border();
  483. INDEX  *IN = AktIndex;
  484. BOOL    StopSuche = FALSE;
  485. BOOL    Gefunden = FALSE;
  486. BOOL    Printed;
  487. UCOUNT    jr,ir;
  488. USHORT    Laenge;
  489. STRPTR    Help;
  490.  
  491. if((!(Abfr_ReqGr(MainWindow,NULL,&SuchGadget[1],&SuchGadget[0])))
  492. ||(*(SuchBuffer[1]) == '\0'))
  493.     return;
  494. Laenge = strlen(SuchBuffer[1]);
  495. Finde_Datum(SuchBuffer[0]);
  496. AktIndex -= 20;
  497.  
  498. do
  499.     {
  500.     if((AktIndex += 20) > MaxIndex)  AktIndex = MaxIndex;
  501.     Set_Screen_Title(MAINWIND,WORKTITEL);
  502.     Lade_Seite(AktIndex);
  503.     Printed = FALSE;
  504.     for(jr=0;(jr<20) && (StopSuche==FALSE);jr++)
  505.         {
  506.         Help=(STRPTR)(Eintrag+jr);
  507.         for(ir=0;ir<34-Laenge;ir++)
  508.             {
  509.             if(!(strncmp((Help+ir),SuchBuffer[1],Laenge)))
  510.                 {
  511.                 if(Printed == FALSE)
  512.                     {
  513.                     Printed = TRUE;
  514.                     IN = AktIndex;
  515.                     Print_Seite();
  516.                     }
  517.                 Zeichne_Border(jr,(UBYTE)RED);
  518.                 Set_Screen_Title(MAINWIND,MAINTITEL);
  519.                 if(Gefunden == FALSE)
  520.                     {
  521.                     Gefunden = TRUE;
  522.                     Request(&RequesterKl,MainWindow);
  523.                     }
  524.                 do
  525.                     IDCMP_Abfrage(MainWindow);
  526.                 while(GadID != 20 && GadID != 21);
  527.                 StopSuche = (GadID == 21) ? TRUE : FALSE;
  528.                 Zeichne_Border(jr,(UBYTE)GREY);
  529.                 break;
  530.                 }
  531.             }
  532.         }
  533.     }
  534. while((MaxIndex>AktIndex) && (StopSuche==FALSE));
  535. if(Gefunden == TRUE) EndRequest(&RequesterKl,MainWindow);
  536. Set_Screen_Title(MAINWIND,MAINTITEL);
  537. Beep(MainScreen);
  538. AktIndex = IN;
  539. return;
  540. }
  541.  
  542. /*********************************************************************/
  543.  
  544. VOID Drucken()
  545. {
  546. SHORT        Aktiviere_Zeile();
  547. INDEX        *AbIn = AktIndex+AktiveZeile;
  548. INDEX        *BisIn;
  549. INDEX        *MaxIn = MaxIndex+19;
  550. INDEX        *Lauf;
  551. ULONG        BisDatum;
  552. USHORT        ZeilenMax;
  553. USHORT        ZeilenAkt;
  554. FLOAT        Gesamt = NeuSaldo;
  555. FLOAT        Einzel;
  556. DruckerIO    *DruckIO;
  557.  
  558. Aktiviere_Zeile(AktiveZeile);
  559. if(Abfr_ReqGr(MainWindow,NULL,&FanfoGad,&BisDatGadget))
  560.     {
  561.     Set_Screen_Title(MAINWIND,WORKTITEL);
  562.     BisDatum = DatInLong(SuchBuffer[0]);
  563.     if((BisDatum < MINDATUM)
  564.     || (BisDatum > MAXDATUM)
  565.     || (BisDatum <= AbIn->Datum)
  566.     || ((MaxIndex+19)->Datum == BisDatum))
  567.     BisIn = MaxIn;
  568.     else
  569.     for(BisIn=AbIn;BisIn->Datum <= BisDatum;BisIn++);
  570.  
  571.     for(Lauf=AktIndex+AktiveZeile;Lauf<=MaxIn;++Lauf)
  572.     {
  573.     if((Seek(HauptDatei,(SIZEEINTRAG*Lauf->Nummer)+34L,
  574.     OFFSET_BEGINNING) != DISKERROR)
  575.     && (Read(HauptDatei,&Einzel,4L) != DISKERROR))
  576.         Gesamt-=Einzel;
  577.     else
  578.         {
  579.         Gesamt = 0.0;
  580.         break;
  581.         }
  582.     }
  583.  
  584.     if(Abfr_ReqGr(MainWindow,&ReqText[18],&ReqGad2,NULL))
  585.     {
  586.     if((DruckIO = DruckerOnOff(ON)) != NULL)
  587.         {
  588.         DruckString(DruckIO,(STRPTR)"\0");
  589.         DruckCom(DruckIO,aSLRM,5L,75L,0L,0L);
  590.         if(DraftGad.Flags & SELECTED)
  591.         DruckCom(DruckIO,aDEN2,0L,0L,0L,0L);
  592.         DruckString(DruckIO,DruckUber);
  593.         ZeilenMax=(FanfoGad.Flags & SELECTED) ? EINZELSIZE : ENDLOSSIZE;
  594.         for(ZeilenAkt=4; AbIn<=BisIn ;AbIn++,ZeilenAkt++)
  595.         {
  596.         if(!((Seek(HauptDatei,(SIZEEINTRAG*AbIn->Nummer),
  597.                        OFFSET_BEGINNING) != DISKERROR)
  598.         && (Read(HauptDatei,EingabeBuffer[1],34L) != DISKERROR)
  599.         && (Read(HauptDatei,&Einzel,4L) != DISKERROR)))
  600.             {
  601.             Disk_Fehler(MainWindow);
  602.             break;
  603.             }
  604.         Gesamt+=Einzel;
  605.         sprintf(TempTextGr,"%s    %-33s    %9.2f    %9.2f\n",
  606.              DatInAsc(AbIn->Datum),EingabeBuffer[1],Einzel,Gesamt);
  607.         DruckString(DruckIO,TempTextGr);
  608.         if(ZeilenAkt == ZeilenMax)
  609.             {
  610.             if(ZeilenMax == EINZELSIZE)
  611.             if(!(Abfr_ReqGr(MainWindow,&ReqText[18],&ReqGad2,NULL)))
  612.                 break;
  613.             DruckString(DruckIO,DruckUber);
  614.             ZeilenAkt = 3;
  615.             }
  616.         }
  617.         DruckString(DruckIO,(STRPTR)"\f");
  618.         DruckCom(DruckIO,aRIN,0L,0L,0L,0L);
  619.         DruckerOnOff(OFF);
  620.         }
  621.         else
  622.             {
  623.         Abfr_ReqGr(MainWindow,&ReqText[19],&ReqGad1,NULL);
  624.             }
  625.     }
  626.     Set_Screen_Title(MAINWIND,MAINTITEL);
  627.     }
  628. return;
  629. }
  630.  
  631. /*********************************************************************/
  632.  
  633. VOID Saldo_Suchen()
  634. {
  635. SHORT    Aktiviere_Zeile();
  636. BOOL    Ok = TRUE;
  637. INDEX    *MaxIn = MaxIndex+19;
  638. INDEX    *Lauf;
  639. FLOAT    Gesamt = NeuSaldo;
  640. FLOAT    Einzel;
  641.  
  642. Set_Screen_Title(MAINWIND,WORKTITEL);
  643. for(Lauf=AktIndex+AktiveZeile+1;Lauf<=MaxIn;++Lauf)
  644.         {
  645.     if((Seek(HauptDatei,(SIZEEINTRAG*Lauf->Nummer)+34L,
  646.     OFFSET_BEGINNING) != DISKERROR)
  647.     && (Read(HauptDatei,&Einzel,4L) != DISKERROR))
  648.         {
  649.         Gesamt-=Einzel;
  650.         }
  651.     else
  652.         {
  653.         Ok = FALSE;
  654.         break;
  655.         }
  656.     }
  657. Set_Screen_Title(MAINWIND,MAINTITEL);
  658. if(Ok)
  659.     {
  660.     sprintf(TempText,"%.2f DM.",Gesamt);
  661.     ReqText[16].LeftEdge = (390-(strlen(TempText)*8))/2;
  662.     ReqText[16].IText    = TempText;
  663.     Abfr_ReqGr(MainWindow,&ReqText[16],&ReqGad1,NULL);
  664.     }
  665. else
  666.     {
  667.     Disk_Fehler(MainWindow);
  668.     }
  669. Aktiviere_Zeile(AktiveZeile);
  670. return;
  671. }
  672.  
  673. /*********************************************************************/
  674.  
  675. VOID Aendere_Eintrag()
  676. {
  677. VOID     EingabeDaten_Auswertung();
  678. VOID     Loesch_Str_Gadgets();
  679. SHORT    Aktiviere_Zeile();
  680. FLOAT    saldo;
  681.  
  682. On_Str_Gadgets();
  683. strcpy(EingabeBuffer[0],DatInAsc((AktIndex+AktiveZeile)->Datum));
  684. strcpy(EingabeBuffer[1],Eintrag+AktiveZeile);
  685. strcpy(EingabeBuffer[2],BetrInAsc((Eintrag+AktiveZeile)->Betrag));
  686. NeuSaldo -= (saldo = (Eintrag+AktiveZeile)->Betrag);
  687. RefreshGadgets(MainWindow->FirstGadget,MainWindow,NULL);
  688. ActivateGadget(EingabeGadget,MainWindow,NULL);
  689.  
  690. while(!((MessClass == GADGETUP) && (GadID == 12)))
  691.     {
  692.     IDCMP_Abfrage(MainWindow);
  693.     if((GadID == 10) || (GadID == 11))
  694.         ActivateGadget(&EingabeGadget[GadID-9],MainWindow,NULL);
  695.     }
  696.  
  697. Off_Str_Gadgets();
  698. Aktiviere_Zeile(AktiveZeile);
  699.  
  700. if(strcmp(EingabeBuffer[0],DatInAsc((AktIndex+AktiveZeile)->Datum))
  701. ||(strcmp(EingabeBuffer[1],Eintrag+AktiveZeile))
  702. ||(strcmp(EingabeBuffer[2],BetrInAsc(saldo))))
  703.     {
  704.     EingabeDaten_Auswertung(AktIndex+AktiveZeile,0);
  705.     Menu_Saven(AN);
  706.     Print_And_Sort();
  707.     }
  708. else
  709.     {
  710.     NeuSaldo += saldo;
  711.     Beep(MainScreen);
  712.     Loesch_Str_Gadgets();
  713.     }
  714. return;
  715. }
  716.  
  717. /*********************************************************************/
  718.  
  719. VOID Loesche_Eintrag()
  720. {
  721. if(NeuDatenAkt >20)
  722.     {
  723.     if(Abfr_ReqGr(MainWindow,&ReqText[3],&ReqGad2,NULL))
  724.         {
  725.         (AktIndex+AktiveZeile)->Datum = 1L;
  726.         NeuSaldo -= (Eintrag+AktiveZeile)->Betrag;
  727.         --NeuDatenAkt;
  728.         Aktiviere_Zeile(AktiveZeile);
  729.         PrintNeuSaldo();
  730.         Print_And_Sort();
  731.         Menu_Saven(AN);
  732.         Geaendert = TRUE;
  733.         }
  734.     }
  735. else
  736.     {
  737.     Beep(MainScreen);
  738.     }
  739. return;
  740. }
  741.  
  742. /*********************************************************************/
  743.  
  744. VOID Neue_Datei()
  745. {
  746. BOOL            Open_Datei();
  747. BOOL            Load_Index();
  748. BOOL            Ok = FALSE;
  749. INDEX            *IND = NULL;
  750. EINTRAG            *EIN = NULL;
  751. STRPTR            TempInText = NULL;
  752. STRPTR            TempDaText = NULL;
  753. UCOUNT            ir;
  754. USHORT             Minimum = 19;
  755. USHORT            AbIndex = DATENMAX-Minimum;
  756. static TEXT        HaAlt[] = "HaDat";
  757. static TEXT        InAlt[] = "InDat";
  758. struct FileHandle     *IndexTemp = NULL;
  759. struct FileHandle    *DateiTemp = NULL;
  760.  
  761. if(!(Abfr_ReqGr(MainWindow,&ReqText[10],&ReqGad2,NULL)))
  762.     return;
  763. while(Geaendert == TRUE)
  764.     {
  765.     if(!(Save_All()))
  766.         {
  767.             Disk_Fehler(MainWindow);
  768.         if(!(Abfr_ReqGr(MainWindow,&ReqText[11],&ReqGad2,NULL)))
  769.             return;
  770.         }
  771.     }
  772.  
  773. if(!((IND=(INDEX*)AllocMem(INDEXLENG,MEMF_PUBLIC|MEMF_CLEAR)))
  774. ||(!(EIN=(EINTRAG*)AllocMem(SIZEEINTRAG*20,MEMF_PUBLIC|MEMF_CLEAR)))
  775. ||(!(TempInText=(STRPTR)AllocMem(30L,MEMF_PUBLIC|MEMF_CLEAR)))
  776. ||(!(TempDaText=(STRPTR)AllocMem(30L,MEMF_PUBLIC|MEMF_CLEAR))))
  777.     {
  778.     if(IND)
  779.         FreeMem(IND,INDEXLENG);
  780.     if(EIN)
  781.         FreeMem(EIN,SIZEEINTRAG*20);
  782.     if(TempInText)
  783.         FreeMem(TempInText,30L);
  784.     Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
  785.     return;
  786.     }
  787.  
  788. if(AktIndex != MaxIndex)  PrintUntereSeite();
  789. Set_Screen_Title(MAINWIND,WORKTITEL);
  790. for(ir=0;ir<20;ir++,AbIndex++)
  791.     {
  792.     (IND+AbIndex)->Datum  = (Index+AbIndex)->Datum;
  793.     (IND+AbIndex)->Nummer = ir;
  794.     strcpy((EIN+ir),(Eintrag+ir));
  795.     (EIN+ir)->Betrag = (Eintrag+ir)->Betrag;
  796.     }
  797.  
  798. sprintf(TempInText,"%s-%s",IndexName,Datum());
  799. sprintf(TempDaText,"%s-%s",DateiName,Datum());
  800.  
  801. if((IndexTemp=Open(TempInText,MODE_NEWFILE))
  802. &&(Write(IndexTemp,IND,INDEXLENG) != DISKERROR))
  803.     {
  804.     Close(IndexTemp);
  805.     if((DateiTemp=Open(TempDaText,MODE_NEWFILE))
  806.     &&(Write(DateiTemp,EIN,(LONG)SIZEEINTRAG*20) != DISKERROR)
  807.     &&(Write(DateiTemp,&Minimum,2L) != DISKERROR)
  808.     &&(Write(DateiTemp,&NeuSaldo,4L) != DISKERROR)
  809.     &&(Write(DateiTemp,&Minimum,2L) != DISKERROR))
  810.         {
  811.         Close(DateiTemp);
  812.         Close(HauptDatei);
  813.         HauptDatei=NULL;
  814.         if((Rename(DateiName,HaAlt))
  815.         &&(Rename(IndexName,InAlt))
  816.         &&(Rename(TempDaText,DateiName))
  817.         &&(Rename(TempInText,IndexName))
  818.         &&(Rename(HaAlt,TempDaText))
  819.         &&(Rename(InAlt,TempInText))
  820.         &&(SetProtection(TempDaText,5L))
  821.         &&(SetProtection(TempInText,5L)))
  822.             Ok = TRUE;
  823.         }
  824.     }
  825. if(!(Ok))
  826.     {
  827.     if(HauptDatei)
  828.         Close(HauptDatei);
  829.     if(IndexTemp)
  830.         Close(IndexTemp);
  831.     if(DateiTemp)
  832.         Close(DateiTemp);
  833.     HauptDatei=NULL;
  834.     Disk_Fehler(MainWindow);
  835.     }
  836. FreeMem(IND,INDEXLENG);
  837. FreeMem(Index,INDEXLENG);
  838. FreeMem(EIN,SIZEEINTRAG*20);
  839. FreeMem(Eintrag,SIZEEINTRAG*20);
  840. FreeMem(TempInText,30L);
  841. FreeMem(TempDaText,30L);
  842. if(!(Load_Index() && Open_Datei()))
  843.     Disk_Fehler(MainWindow);
  844. return;
  845. }
  846.  
  847. /*********************************************************************/
  848.  
  849. VOID Neues_Saldo()
  850. {
  851. FLOAT saldo;
  852.  
  853. if((Abfr_ReqGr(MainWindow,&ReqText[14],&NeuSalGad,&NeuSalGad))
  854. &&(*(SuchBuffer[2]) != '\0')
  855. &&((saldo = (FLOAT)atof(SuchBuffer[2])) <= MAXFLOAT)
  856. &&(saldo >= MINFLOAT)) 
  857.     {
  858.     NeuSaldo = saldo;
  859.     PrintNeuSaldo();
  860.     }
  861. return;
  862. }
  863.  
  864. /*********************************************************************/
  865.  
  866. VOID Monats_Daten()
  867. {
  868. VOID    End_Monat();
  869. VOID    Mon_Auswert();
  870. VOID    Print_Monat();
  871. BOOL    Open_MonGraphs();
  872. BOOL    Open_MonatDat();
  873.  
  874.  
  875. if(Open_MonGraphs())
  876.     if(Open_MonatDat())
  877.         {
  878.         Print_Monat(AktMonat);
  879.         Mon_Auswert();
  880.         }
  881. End_Monat();
  882. return;
  883. }
  884.  
  885. /*********************************************************************/
  886.  
  887. VOID Monat_Hinzu()
  888. {
  889. VOID EingabeDaten_Auswertung();
  890. LONG    Mon;
  891. UCOUNT    i = 0;
  892. struct FileHandle *MonatDatei = (struct FileHandle *) NULL;
  893.  
  894. *(SuchBuffer[0]) = '\0';
  895. if(!(Monat = (MONAT *)AllocMem(MONATLENG,MEMF_CLEAR|MEMF_PUBLIC)))
  896.     Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
  897. else
  898.     {
  899.     if(Abfr_ReqGr(MainWindow,&ReqText[25],&SuchGadget[0],&SuchGadget[0]))
  900.     {
  901.     Set_Screen_Title(MAINWIND,WORKTITEL);
  902.     if((Mon = atol(SuchBuffer[0]+3)) < 1L || Mon > 12L)
  903.         Mon = atol(Datum()+3);
  904.     if(!((MonatDatei = Open(MonatName,MODE_READWRITE))
  905.     &&(Seek(MonatDatei,(Mon-1L)*MONATLENG,OFFSET_BEGINNING) != DISKERROR)
  906.     &&(Read(MonatDatei,Monat,MONATLENG) != DISKERROR)))
  907.         Disk_Fehler(MainWindow);
  908.     else
  909.         {
  910.         while((*((Monat+i)->Bezeichnung) != '\0') && (i < MONEINT))
  911.         {
  912.         strcpy(EingabeBuffer[0],SuchBuffer[0]);
  913.         strcpy(EingabeBuffer[1],(Monat+i)->Bezeichnung);
  914.         strcpy(EingabeBuffer[2],BetrInAsc((Monat+i)->Betrag));
  915.         EingabeDaten_Auswertung(Index+DATENMAX-(++NeuDatenAkt),1);
  916.         i++;
  917.         }
  918.         Menu_Saven(AN);
  919.         Print_And_Sort();
  920.         }
  921.     if(MonatDatei)
  922.         Close(MonatDatei);
  923.     FreeMem(Monat,MONATLENG);
  924.     Set_Screen_Title(MAINWIND,MAINTITEL);
  925.     *(SuchBuffer[0]) = '\0';
  926.     }
  927.     }
  928. return;
  929. }
  930.  
  931. /*********************************************************************/
  932. /*********************************************************************/
  933.  
  934. BOOL Save_All()
  935. {
  936. BOOL Ok=FALSE;
  937.  
  938. Set_Screen_Title(MAINWIND,WORKTITEL);
  939. if((DateiIndex=Open(IndexName,MODE_NEWFILE))
  940. &&(Write(DateiIndex,Index,INDEXLENG) != DISKERROR)
  941. &&(Seek(HauptDatei,NULL,OFFSET_END) != DISKERROR)
  942. &&(Write(HauptDatei,(USHORT*)&NeuDatenAkt,2L) != DISKERROR)
  943. &&(Write(HauptDatei,(FLOAT*)&NeuSaldo,4L) != DISKERROR)
  944. &&(Write(HauptDatei,(USHORT*)&NeuVergeben,2L) != DISKERROR))
  945.     {
  946.     Menu_Saven(AUS);
  947.     Geaendert = FALSE;
  948.     DatenAkt = NeuDatenAkt;
  949.     Ok=TRUE;
  950.     }
  951. if(DateiIndex)
  952.     Close(DateiIndex);
  953. DateiIndex = NULL;
  954. Set_Screen_Title(MAINWIND,MAINTITEL);
  955. return(Ok);
  956. }
  957.  
  958. /*********************************************************************/
  959.  
  960. BOOL Abfr_ReqGr(Window,ReqText,ReqGadget,ActGadget)
  961. struct Window    *Window;
  962. struct IntuiText *ReqText;
  963. struct Gadget     *ReqGadget;
  964. struct Gadget     *ActGadget;
  965. {
  966. BOOL AbfrSchluss;
  967. BOOL Erfolg;
  968.  
  969. RequesterGr.ReqGadget = ReqGadget;
  970. RequesterGr.ReqText   = ReqText;
  971.  
  972. if(Request(&RequesterGr,Window))
  973.     {
  974.     Delay(5L);
  975.     AbfrSchluss = Erfolg = FALSE;
  976.     if(ActGadget)
  977.         ActivateGadget(ActGadget,Window,&RequesterGr);
  978.     do
  979.         {
  980.         IDCMP_Abfrage(Window);
  981.         switch(GadID)
  982.             {
  983.             case 13:
  984.             if(ReqGadget==&SuchGadget[1])
  985.                 {
  986.                 ActivateGadget(ReqGadget,
  987.                 Window,&RequesterGr);
  988.                 break;
  989.                 }
  990.             AbfrSchluss = Erfolg = TRUE;
  991.             break;
  992.  
  993.             case 14:
  994.             case 15:
  995.             case 20:
  996.             case 39:
  997.             AbfrSchluss = Erfolg = TRUE;
  998.             break;
  999.  
  1000.             case 21:
  1001.             AbfrSchluss = TRUE;
  1002.             break;
  1003.  
  1004.             case 37:
  1005.             if(ReqGadget == &MonStrGad[2])
  1006.                 ActivateGadget(&MonStrGad[1],
  1007.                 Window,&RequesterGr);
  1008.             break;
  1009.  
  1010.             case 38:
  1011.             ActivateGadget(&MonStrGad[2],Window,&RequesterGr);
  1012.             break;
  1013.             }
  1014.         }
  1015.     while(AbfrSchluss == FALSE);
  1016.     EndRequest(&RequesterGr,Window);
  1017.     }
  1018. return(Erfolg);
  1019. }
  1020.  
  1021. /*********************************************************************/
  1022.  
  1023. BOOL Abfrage_EingabeSchluss(Nummer)
  1024. USHORT Nummer;
  1025. {
  1026. VOID    EingabeDaten_Auswertung();
  1027. BOOL     EingabeSchluss;
  1028.  
  1029. EingabeSchluss = *(EingabeBuffer[Nummer]) == '\0' ? TRUE : FALSE;
  1030. if(++Nummer >2 && EingabeSchluss == FALSE)
  1031.     {
  1032.     Nummer = 0;
  1033.     EingabeDaten_Auswertung(Index+DATENMAX-(++NeuDatenAkt),1);
  1034.     Loesch_Str_Gadgets();
  1035.     }
  1036. if(EingabeSchluss == FALSE)
  1037.     ActivateGadget(&EingabeGadget[Nummer],MainWindow,NULL);
  1038. return(EingabeSchluss);
  1039. }
  1040.  
  1041. /*********************************************************************/
  1042.  
  1043. VOID EingabeDaten_Auswertung(Frei,VonWo)
  1044. INDEX *Frei;
  1045. USHORT VonWo;
  1046. {
  1047. VOID   Loesch_Str_Gadgets();
  1048.  
  1049. static ULONG  Dat;
  1050. static FLOAT  Bet;
  1051.  
  1052. Set_Screen_Title(MAINWIND,WORKTITEL);
  1053. Dat = DatInLong(EingabeBuffer[0]);            /* Datum umrechnen */
  1054. if(Dat < MINDATUM || Dat > MAXDATUM)
  1055.     Dat = DatInLong(Datum());
  1056. Bet=(FLOAT)atof(EingabeBuffer[2]);            /* Betrag umrechn. */
  1057. if(Bet > MAXFLOAT || Bet < MINFLOAT)
  1058.     Bet = 0.0; 
  1059. NeuSaldo += Bet;
  1060.  
  1061. if(VonWo)
  1062.     {
  1063.     ScrollRaster(Main_rp,0L,9L,10L,31L,610L,210L);    /* Ausgabe in Wind */
  1064.     PrintEintrag(Dat,EingabeBuffer[1],Bet,yUnt);
  1065.     if(Frei->Datum != 1L)                /* noch nie belegt */
  1066.         Frei->Nummer = ++NeuVergeben;
  1067.     } /* von der normalen Eingaberoutine */
  1068.  
  1069. Frei->Datum = Dat;                    /* Vorbereitung */
  1070.  
  1071. if
  1072. (!((Seek(HauptDatei,SIZEEINTRAG*(Frei->Nummer),OFFSET_BEGINNING) != DISKERROR)
  1073. &&(Write(HauptDatei,EingabeBuffer[1],34L) != DISKERROR)
  1074. &&(Write(HauptDatei,&Bet,4L) != DISKERROR)))
  1075.     Disk_Fehler(MainWindow);
  1076. PrintNeuSaldo();
  1077. Geaendert = TRUE;
  1078. Loesch_Str_Gadgets();
  1079. Set_Screen_Title(MAINWIND,MAINTITEL);
  1080. return;
  1081. }
  1082.  
  1083. /*********************************************************************/
  1084.  
  1085. SHORT Aktiviere_Zeile(Zeile)
  1086. SHORT(Zeile);
  1087. {
  1088. VOID    Zeichne_Border();
  1089. static    SHORT BufferZeile = -1;
  1090. UCOUNT    i;
  1091.  
  1092. if(BufferZeile < 0)
  1093.     {
  1094.     BufferZeile = Zeile;
  1095.     Menu_Normal(AUS);
  1096.     for(i=0;i<3;i++)
  1097.         OffGadget(&ScrollGadget[i],MainWindow,NULL);
  1098.     Zeichne_Border(Zeile,(UBYTE)RED);
  1099.     }
  1100. else
  1101.     {
  1102.     if(Zeile == BufferZeile)
  1103.         {
  1104.         BufferZeile = -1;
  1105.         Menu_Normal(AN);
  1106.         for(i=0;i<3;i++)
  1107.             OnGadget(&ScrollGadget[i],MainWindow,NULL);
  1108.         Zeichne_Border(Zeile,(UBYTE)GREY);
  1109.         }
  1110.     }
  1111. return(BufferZeile);
  1112. }
  1113.  
  1114. /*********************************************************************/
  1115.  
  1116. VOID Zeichne_Border(Zeile,Farbe)
  1117. USHORT Zeile;
  1118. UBYTE  Farbe;
  1119. {
  1120. WahlBorder.FrontPen = Farbe;
  1121. DrawBorder(Main_rp,&WahlBorder,8L,(LONG)(31+(Zeile*9)));
  1122. return;
  1123. }
  1124.  
  1125. /*********************************************************************/
  1126.  
  1127. VOID Off_Str_Gadgets()
  1128. {
  1129. register UCOUNT ir;
  1130.  
  1131. for(ir=0;ir<3;ir++)
  1132.     OffGadget(&EingabeGadget[ir],MainWindow,NULL);
  1133. return;
  1134. }
  1135.  
  1136. /*********************************************************************/
  1137.  
  1138. VOID On_Str_Gadgets()
  1139. {
  1140. register UCOUNT ir;
  1141.  
  1142. for(ir=0;ir<3;ir++)
  1143.     OnGadget(&EingabeGadget[ir],MainWindow,NULL);
  1144. LoeschFeld(Main_rp, 12L,225L,9);
  1145. LoeschFeld(Main_rp,108L,225L,34);
  1146. return;
  1147. }
  1148.  
  1149. /*********************************************************************/
  1150.  
  1151. VOID Loesch_Str_Gadgets()
  1152. {
  1153. *EingabeBuffer[0]=*EingabeBuffer[1]=*EingabeBuffer[2]='\0';
  1154. RefreshGadgets(MainWindow->FirstGadget,MainWindow,NULL);
  1155. return;
  1156. }
  1157.  
  1158. /*********************************************************************/
  1159.  
  1160. VOID Disk_Fehler(Window)
  1161. struct Window *Window;
  1162. {
  1163. USHORT DiskFehler = (USHORT)IoErr();
  1164. struct IntuiText *Help;
  1165.  
  1166. sprintf(TempText,"IoError Nr. %03u ",DiskFehler);
  1167. ReqText[7].IText = TempText;
  1168. Help = (Geaendert) ? &ReqText[9] : &ReqText[8];
  1169. if(!(Abfr_ReqGr(Window,Help,&ReqGad2,NULL)))
  1170.     if((Geaendert) && (Window == MainWindow))
  1171.         if(!(Abfr_ReqGr(Window,&ReqText[1],&ReqGad2,NULL)))
  1172.             EndProgramm(DiskFehler);
  1173. return;
  1174. }
  1175.  
  1176. /*********************************************************************/
  1177.  
  1178. VOID PrintNachUnten()
  1179. {
  1180. register i;
  1181.  
  1182. if(AktIndex != MaxIndex)
  1183.     {
  1184.     Set_Screen_Title(MAINWIND,WORKTITEL);
  1185.     AktIndex+=20;
  1186.     if(AktIndex > MaxIndex)    AktIndex=MaxIndex;
  1187.     Lade_Seite(AktIndex);
  1188.     for(i=0;i<20;i++)
  1189.           {
  1190.         ScrollRaster(Main_rp,0L,9L,10L,31L,610L,210L);
  1191.         PrintEintrag
  1192.         ((AktIndex+i)->Datum,
  1193.         (Eintrag+i)->Bezeichnung,
  1194.         (Eintrag+i)->Betrag,
  1195.         yUnt);
  1196.         }
  1197.     Set_Screen_Title(MAINWIND,MAINTITEL);
  1198.     }
  1199. else    Beep(MainScreen);
  1200. return;
  1201. }
  1202.  
  1203. /*********************************************************************/
  1204.  
  1205. VOID PrintNachOben()
  1206. {
  1207. register i;
  1208. INDEX *min = Index+DATENMAX-NeuDatenAkt;
  1209.  
  1210. if (AktIndex != min)
  1211.     {
  1212.     Set_Screen_Title(MAINWIND,WORKTITEL);
  1213.     AktIndex-=20;
  1214.     if(AktIndex < min)    AktIndex=min;
  1215.     Lade_Seite(AktIndex);
  1216.     for(i=19;i>-1;i--)
  1217.         {
  1218.         ScrollRaster(Main_rp,0L,-9L,10L,31L,610L,210L);
  1219.         PrintEintrag 
  1220.         ((AktIndex+i)->Datum,
  1221.         (Eintrag+i)->Bezeichnung,
  1222.         (Eintrag+i)->Betrag,
  1223.         yOben);
  1224.         }
  1225.     Set_Screen_Title(MAINWIND,MAINTITEL);
  1226.     }
  1227. else    Beep(MainScreen);
  1228. return;
  1229. }
  1230.  
  1231. /*********************************************************************/
  1232.  
  1233. VOID PrintUntereSeite()
  1234. {
  1235. AktIndex=Index+DATENMAX;
  1236. PrintNachUnten();
  1237. return;
  1238. }
  1239.  
  1240. /*********************************************************************/
  1241.  
  1242. VOID Print_And_Sort()
  1243. {
  1244. UCOUNT Zaehler;
  1245.  
  1246. Set_Screen_Title(MAINWIND,WORKTITEL);
  1247. Sort_Index();
  1248. if(++AktIndex > MaxIndex)
  1249.     --AktIndex;
  1250. Lade_Seite(AktIndex);
  1251. Print_Seite();
  1252. Set_Screen_Title(MAINWIND,MAINTITEL);
  1253. return;
  1254. }
  1255.  
  1256. /*********************************************************************/
  1257.  
  1258. VOID Print_Seite()
  1259. {
  1260. REGISTER UCOUNT Zaehler;
  1261.  
  1262. for(Zaehler=0;Zaehler<20;Zaehler++)
  1263.     {
  1264.     LoeschFeld(Main_rp,xDatum,yOben+(Zaehler*9),75);
  1265.     PrintEintrag((AktIndex+Zaehler)->Datum,
  1266.         (Eintrag+Zaehler)->Bezeichnung,
  1267.         (Eintrag+Zaehler)->Betrag,yOben+(Zaehler*9));
  1268.     }
  1269. return;
  1270. }
  1271.  
  1272. /*********************************************************************/
  1273.  
  1274. VOID PrintNeuSaldo()
  1275. {
  1276. LoeschFeld(Main_rp,xPlus,248L,25);
  1277. Print(Main_rp,BetrInAsc(NeuSaldo),TAB(NeuSaldo),248L,FAR(NeuSaldo));
  1278. return;
  1279. }
  1280.  
  1281. /*********************************************************************/
  1282.  
  1283. VOID PrintEintrag(dat,bez,bet,pos)
  1284. long        dat;
  1285. STRPTR        bez;
  1286. float        bet;
  1287. long        pos;
  1288. {
  1289. Print(Main_rp,DatInAsc(dat),xDatum,pos,BLUE);
  1290. Print(Main_rp,bez,xBez,pos,BLUE);
  1291. Print(Main_rp,BetrInAsc(bet),TAB(bet),pos,FAR(bet));
  1292. return;
  1293. }
  1294.  
  1295. /*********************************************************************/
  1296.  
  1297. VOID Print(rp,text,x,y,far)
  1298. struct RastPort *rp;
  1299. STRPTR text;
  1300. long x,y,far;
  1301. {
  1302. SetAPen(rp,far);
  1303. Move(rp,x,y);
  1304. Text(rp,text,(LONG)strlen(text));
  1305. return;
  1306. }
  1307.  
  1308. /*********************************************************************/
  1309.  
  1310. VOID LoeschFeld(rp,x,y,len)
  1311. struct Rastport *rp;
  1312. ULONG x,y;
  1313. USHORT len;
  1314. {
  1315. SetAPen(rp,GREY);
  1316. RectFill(rp,x,y-6,x+(8*len),y+2);
  1317. return;
  1318. }
  1319.  
  1320. /*********************************************************************/
  1321.  
  1322. ULONG DatInLong(DatAsc)
  1323. STRPTR DatAsc;
  1324. {
  1325. STRPTR p;
  1326. ULONG DatLong = 0;
  1327. ULONG Mal = 10000L;
  1328.  
  1329. p=DatAsc+6;
  1330.  
  1331. while(p>=DatAsc)
  1332.     {
  1333.     DatLong+=(Mal*atol(p));
  1334.     p-=3;
  1335.     Mal/=100;
  1336.     }
  1337. return(DatLong);
  1338. }
  1339.  
  1340. /*********************************************************************/
  1341.  
  1342. STRPTR DatInAsc(DatLong)
  1343. ULONG DatLong;
  1344. {
  1345. ULONG a=10000L;
  1346. ULONG b=100L;
  1347. ULONG c[3];
  1348.  
  1349. c[0]=DatLong/a;
  1350. c[1]=(DatLong-(c[0]*a))/b;
  1351. c[2]=DatLong-(c[0]*a)-(c[1]*b);
  1352. sprintf(TempText,"%02lu.%02lu.%02lu",c[2],c[1],c[0]);
  1353. return(TempText);
  1354. }
  1355.  
  1356. /*********************************************************************/
  1357.  
  1358. VOID Finde_Datum(AscDatum)
  1359. STRPTR AscDatum;
  1360. {
  1361. ULONG Datum = DatInLong(AscDatum);
  1362.  
  1363. if(Datum < MINDATUM)    Datum = MINDATUM;
  1364. if(Datum > MAXDATUM)    Datum = MAXDATUM;
  1365. AktIndex = Index;
  1366. while(AktIndex->Datum < Datum)
  1367.     AktIndex++;
  1368. return;
  1369. }
  1370.  
  1371. /*********************************************************************/
  1372.  
  1373. VOID Setz_VonBis(IN)
  1374. INDEX *IN;
  1375. {
  1376. register UCOUNT i;
  1377. register USHORT x=155,y=240;
  1378.  
  1379. for(i=0;i<2;i++)
  1380.     {
  1381.     Print(Main_rp,DatInAsc(IN->Datum),(LONG)x,(LONG)y,BLACK);
  1382.     y += 8;
  1383.     IN += 19;
  1384.     }
  1385. return;
  1386. }
  1387.  
  1388. /*********************************************************************/
  1389.  
  1390. STRPTR BetrInAsc(Saldo)
  1391. float Saldo;
  1392. {
  1393. sprintf(TempText,"%9.2f",Saldo);
  1394. return(TempText);
  1395. }
  1396.  
  1397. /*********************************************************************/
  1398.  
  1399. STRPTR Datum()
  1400. {
  1401. struct tm *Zeit;
  1402. long  Z;
  1403.  
  1404. Z    = time(NULL);
  1405. Zeit = localtime(&Z);
  1406. sprintf(TempText,"%02d.%02d.%02d",Zeit->tm_mday,(Zeit->tm_mon)+1,Zeit->tm_year);
  1407. return(TempText);
  1408. }
  1409.  
  1410. /*********************************************************************/
  1411.  
  1412. BOOL Sort_Index()
  1413. {
  1414. VOID   Sort();
  1415.  
  1416. if(!(LG = (USHORT*)AllocMem(500L,MEMF_CLEAR)))
  1417.     return(FALSE);
  1418. if(!(RG = (USHORT*)AllocMem(500L,MEMF_CLEAR)))
  1419.     {
  1420.     FreeMem(LG,500L);
  1421.     return(FALSE);
  1422.     }
  1423. LG[1]=0;
  1424. RG[1]=DATENMAX;
  1425. Sort();
  1426. FreeMem(RG,500L);
  1427. FreeMem(LG,500L);
  1428. return(TRUE);
  1429. }
  1430.  
  1431. VOID Sort()
  1432. {
  1433. VOID swapmem();
  1434. static ULONG vg;
  1435. static SHORT z,x,y;
  1436.  
  1437. z++;
  1438.  
  1439. if(LG[z] >= RG[z])
  1440.     {
  1441.     z--;
  1442.     return;
  1443.     }
  1444.  
  1445. x=LG[z];
  1446. y=RG[z];
  1447. vg=(Index+((x+y)/2))->Datum;
  1448.  
  1449. MARK:
  1450. if(x > y)
  1451.     {
  1452.     RG[z+1]=y;
  1453.     LG[z+1]=LG[z];
  1454.     Sort();
  1455.     LG[z+1]=x;
  1456.     RG[z+1]=RG[z];
  1457.     Sort();
  1458.     z--;
  1459.     return;
  1460.     }
  1461.  
  1462. while ((Index+x)->Datum < vg)    x++;
  1463. while ((Index+y)->Datum > vg)    y--;
  1464.  
  1465. if(x > y)
  1466.     {
  1467.     RG[z+1]=y;
  1468.     LG[z+1]=LG[z];
  1469.     Sort();
  1470.     LG[z+1]=x;
  1471.     RG[z+1]=RG[z];
  1472.     Sort();
  1473.     z--;
  1474.     return;
  1475.     }
  1476.  
  1477. swapmem((char*)(Index+y),(char*)(Index+x),6);
  1478.  
  1479. x++;
  1480. y--;
  1481. goto MARK;
  1482. }
  1483.  
  1484. /*********************************************************************/
  1485.  
  1486. VOID Menu_Normal(AnAus)
  1487. USHORT AnAus;
  1488. {
  1489. static USHORT Menus[] = {6,  2, 3, 4, 3, 2, 2};
  1490. UCOUNT i;
  1491.  
  1492. for(i=1;i<=Menus[0];i++)
  1493.     Menu_Schalt(MainWindow,i-1,Menus[i],AnAus);
  1494. Menu_Schalt(MainWindow,2,4,(AnAus==AN) ? AUS : AN);
  1495. return;
  1496. }
  1497.  
  1498. /*********************************************************************/
  1499.  
  1500. VOID Menu_Saven(AnAus)
  1501. USHORT AnAus;
  1502. {
  1503. Menu_Schalt(MainWindow,1,2,AnAus);
  1504. return;
  1505. }
  1506.  
  1507. /*********************************************************************/
  1508.  
  1509. VOID Menu_Schalt(Window,MenuNr,ItemNr,An)
  1510. struct Window *Window;
  1511. USHORT MenuNr,ItemNr,An;
  1512. {
  1513. ULONG code = ItemNr*32+MenuNr;
  1514.  
  1515. if(An)
  1516.     OnMenu(Window,code);
  1517. else
  1518.     OffMenu(Window,code);
  1519. return;
  1520. }
  1521.  
  1522. /*********************************************************************/
  1523.  
  1524. VOID Set_Screen_Title(Wohin,Welchen)
  1525. USHORT    Wohin;
  1526. USHORT    Welchen;
  1527. {
  1528. struct Window *Window = (Wohin) ? NebenWindow : MainWindow;
  1529. static STRPTR Titel[3]={
  1530. (STRPTR)"                 -- GiroMan V3.00 Haupt  © 1987/88  --",
  1531. (STRPTR)"                   -- GiroMan V3.00 Monat  © 1988 --",
  1532. (STRPTR)"              -- NICHT STÖREN, GIROMAN IST BESCHÄFTIGT --"};
  1533.  
  1534. SetWindowTitles(Window,FALSE,Titel[Welchen]);
  1535. return;
  1536. }
  1537.  
  1538. /*********************************************************************/
  1539.  
  1540. VOID Beep(Screen)
  1541. struct Screen *Screen;
  1542. {
  1543. int zaehler;
  1544. for (zaehler=1;zaehler<250;zaehler++)
  1545.     DisplayBeep(Screen);
  1546. return;
  1547. }
  1548.  
  1549. /*********************************************************************/
  1550.  
  1551. VOID Lade_Seite(IN)
  1552. INDEX *IN;
  1553. {
  1554. VOID Stell_Prop();
  1555. UCOUNT i;
  1556.  
  1557. Setz_VonBis(IN);
  1558. Stell_Prop();
  1559. for(i=0;i<20;i++)
  1560.     {
  1561.     if(!((Seek(HauptDatei,IN->Nummer*SIZEEINTRAG,OFFSET_BEGINNING) != DISKERROR)
  1562.     &&(Read(HauptDatei,Eintrag+i,SIZEEINTRAG) != DISKERROR)))
  1563.     {
  1564.     Disk_Fehler(MainWindow);
  1565.     return;
  1566.     break;
  1567.     }
  1568.     IN++;
  1569.     }
  1570. return;
  1571. }
  1572.  
  1573. /*********************************************************************/
  1574.  
  1575. VOID Stell_Prop()
  1576. {
  1577. INDEX    *min = Index+DATENMAX-NeuDatenAkt;
  1578. FLOAT    GenauPosi;
  1579. ULONG    NeuPosi;
  1580.  
  1581. NeuProp = (NeuDatenAkt > 20) ? 0xFFFF/((NeuDatenAkt)/20) : 0;
  1582. GenauPosi = ((AktIndex-min)/20.0)+0.999999;
  1583. NeuPosi = (ULONG)GenauPosi*NeuProp;
  1584. ModifyProp(ScrollGadget,MainWindow,NULL,PROPFLAGS,0L,NeuPosi,0L,(ULONG)NeuProp);
  1585. RefreshGadgets(ScrollGadget,MainWindow,NULL);
  1586. return;
  1587. }
  1588.  
  1589. /*********************************************************************/
  1590.  
  1591. VOID Mon_Auswert()
  1592. {
  1593. BOOL Wel_MonGadget();
  1594. VOID Mon_MausAbfrage();
  1595. BOOL Ende = FALSE;
  1596.  
  1597. while(!(Ende))
  1598.     {
  1599.     IDCMP_Abfrage(NebenWindow);
  1600.     switch(MessClass)
  1601.         {
  1602.         case GADGETUP:
  1603.         Ende = Wel_MonGadget();
  1604.         break;
  1605.  
  1606.         case MOUSEBUTTONS:
  1607.         Mon_MausAbfrage();
  1608.         break;
  1609.  
  1610.         case REFRESHWINDOW:
  1611.         Print_Monat(AktMonat);
  1612.         break;        
  1613.         }
  1614.     }
  1615. return;
  1616. }
  1617.  
  1618. /*********************************************************************/
  1619.  
  1620. BOOL Wel_MonGadget()
  1621. {
  1622. VOID Print_Monat();
  1623. VOID Eingabe_Monat();
  1624. VOID Loesch_Monat();
  1625. VOID Aender_Monat();
  1626. BOOL Save_MonDat();
  1627. BOOL Ende = FALSE;
  1628.  
  1629. if(!(MonEinSel))
  1630.     {
  1631.     switch(GadID)
  1632.         {
  1633.         case 30:
  1634.         if(!(MonGeaendert))
  1635.             Ende = TRUE;
  1636.         else
  1637.             if(Abfr_ReqGr(NebenWindow,&ReqText[21],&ReqGad2,NULL))
  1638.                 if(Save_MonDat())
  1639.                     Ende = TRUE;
  1640.         break;
  1641.  
  1642.         case 31:
  1643.         AktMonat = (AktMonat == 11) ? 0 : AktMonat+1;
  1644.         Print_Monat(AktMonat);
  1645.         break;
  1646.  
  1647.         case 32:
  1648.         AktMonat = (AktMonat == 0) ? 11 : AktMonat-1;
  1649.         Print_Monat(AktMonat);
  1650.         break;
  1651.  
  1652.         case 33:
  1653.         if(MonGeaendert)
  1654.             Save_MonDat();
  1655.         break;
  1656.  
  1657.         case 34:
  1658.         Eingabe_Monat();
  1659.         break;
  1660.         }
  1661.     }
  1662. else
  1663.     {
  1664.     switch(GadID)
  1665.         {
  1666.         case 35:
  1667.         Aender_Monat();
  1668.         break;
  1669.  
  1670.         case 36:
  1671.         Loesch_Monat();
  1672.         break;
  1673.         }
  1674.     }
  1675. return(Ende);
  1676. }
  1677.  
  1678. /*********************************************************************/
  1679.  
  1680. VOID Eingabe_Monat()
  1681. {
  1682. SHORT    Sprung;
  1683. BOOL    Erfolg;
  1684. UCOUNT    i;
  1685. UCOUNT    j;
  1686. MONAT    **Find_Pointer();
  1687. MONAT    **Pointer;
  1688. MONAT    *mon;
  1689. FLOAT    saldo;
  1690.  
  1691. *(MonatBuffer[0]) = *(MonatBuffer[1]) = *(MonatBuffer[2]) = '\0';
  1692. if((Abfr_ReqGr(NebenWindow,NULL,&MonStrGad[2],&MonStrGad[0]))
  1693. &&(*(MonatBuffer[1]) != '\0')
  1694. &&(*(MonatBuffer[2]) != '\0')
  1695. &&((saldo=(FLOAT)atof(MonatBuffer[2])) <= MAXFLOAT)
  1696. &&(saldo >= MINFLOAT))
  1697.     {
  1698.     Sprung = (SHORT)-(atol(MonatBuffer[0]));
  1699.     if((Sprung < 1) || (Sprung == 5) || (Sprung > 6))
  1700.         Sprung = 12;
  1701.     Pointer = Find_Pointer(Sprung);
  1702.     for(i=0;i<(12/Sprung);i++)
  1703.         {
  1704.         mon = *(Pointer+i);
  1705.         Erfolg = FALSE;
  1706.         for(j=0;j<MONEINT;j++,mon++)
  1707.             {
  1708.             if(*((mon)->Bezeichnung) == '\0')
  1709.                 {
  1710.                 strcpy((mon)->Bezeichnung,MonatBuffer[1]);
  1711.                 (mon)->Betrag = saldo;
  1712.                 Erfolg = TRUE;
  1713.                 break;
  1714.                 }
  1715.             }
  1716.         if(!(Erfolg))
  1717.             Abfr_ReqGr(NebenWindow,&ReqText[23],&ReqGad1,NULL);
  1718.         }
  1719.     MonGeaendert = TRUE;
  1720.     }
  1721. return;
  1722. }
  1723.  
  1724. /*********************************************************************/
  1725.  
  1726. VOID Aender_Monat()
  1727. {
  1728. VOID Aktiviere_MonZeile();
  1729. MONAT    **Find_Pointer();
  1730. MONAT    **Pointer;
  1731. MONAT    *mon;
  1732. SHORT    Sprung;
  1733. SHORT    i;
  1734. SHORT    j;
  1735. MONAT    *aktmon = Monat+((AktMonat*MONEINT)+AktMonZeile);
  1736. FLOAT    saldo;
  1737.  
  1738. Aktiviere_MonZeile(AktMonZeile);
  1739. strcpy(MonatBuffer[0],All);
  1740. strcpy(MonatBuffer[1],aktmon->Bezeichnung);
  1741. sprintf(MonatBuffer[2],"%9.2f",aktmon->Betrag);
  1742. if((Abfr_ReqGr(NebenWindow,NULL,&MonStrGad[2],&MonStrGad[0]))
  1743. &&(*(MonatBuffer[1]) != '\0')
  1744. &&(*(MonatBuffer[2]) != '\0')
  1745. &&((saldo=(FLOAT)atof(MonatBuffer[2])) <= MAXFLOAT)
  1746. &&(saldo >= MINFLOAT))
  1747.     {
  1748.     Sprung = (strncmp(MonatBuffer[0],All,5)) ? 12 : 1;
  1749.     Pointer = Find_Pointer(Sprung);
  1750.     for(i=(Sprung==12)?0:11;i>-1;i--)
  1751.         {
  1752.         mon = *(Pointer+i);
  1753.         for(j=0;j<MONEINT;j++,mon++)
  1754.             {
  1755.             if(*((mon)->Bezeichnung) == '\0')
  1756.                 break;
  1757.             if((!strcmp((mon)->Bezeichnung,aktmon->Bezeichnung))
  1758.             &&((mon)->Betrag == aktmon->Betrag))
  1759.                 {
  1760.                 strcpy((mon)->Bezeichnung,MonatBuffer[1]);
  1761.                 (mon)->Betrag = saldo;
  1762.                 break;
  1763.                 }
  1764.             }
  1765.         }
  1766.     MonGeaendert = TRUE;
  1767.     }
  1768. return;
  1769. }
  1770.  
  1771. /*********************************************************************/
  1772.  
  1773. VOID Loesch_Monat()
  1774. {
  1775. VOID Aktiviere_MonZeile();
  1776. VOID Aktiviere_MonZeile();
  1777. MONAT    **Find_Pointer();
  1778. MONAT    **Pointer;
  1779. MONAT    *mon;
  1780. SHORT    Sprung;
  1781. SHORT    i;
  1782. SHORT    j;
  1783. MONAT    *aktmon = Monat+((AktMonat*MONEINT)+AktMonZeile);
  1784.  
  1785. Aktiviere_MonZeile(AktMonZeile);
  1786. strcpy(MonatBuffer[0],All);
  1787. if((Abfr_ReqGr(NebenWindow,&ReqText[24],&MonStrGad[0],&MonStrGad[0])))
  1788.     {
  1789.     Sprung = (strncmp(MonatBuffer[0],All,5)) ? 12 : 1;
  1790.     Pointer = Find_Pointer(Sprung);
  1791.     for(i=(Sprung==12)?0:11;i>-1;i--)
  1792.     {
  1793.     mon = *(Pointer+i);
  1794.     for(j=0;j<MONEINT;j++)
  1795.         {
  1796.         if((!strcmp((mon+j)->Bezeichnung,aktmon->Bezeichnung))
  1797.         &&((mon+j)->Betrag == aktmon->Betrag))
  1798.         {
  1799.         *((mon+j)->Bezeichnung) = '\0';
  1800.         while((++j < MONEINT) && (*((mon+j)->Bezeichnung) != '\0'))
  1801.             {
  1802.             strcpy((mon+j-1)->Bezeichnung,(mon+j)->Bezeichnung);
  1803.             (mon+j-1)->Betrag = (mon+j)->Betrag;
  1804.             *((mon+j)->Bezeichnung) = '\0';
  1805.             }
  1806.         }
  1807.         }
  1808.     }
  1809.     MonGeaendert = TRUE;
  1810.     }
  1811. return;
  1812. }
  1813.  
  1814. /*********************************************************************/
  1815.  
  1816. BOOL Save_MonDat()
  1817. {
  1818. BOOL Ok = FALSE;
  1819. struct FileHandle *MonatDatei;
  1820.  
  1821. Set_Screen_Title(MONAWIND,WORKTITEL);
  1822. if(!((MonatDatei = Open(MonatName,MODE_NEWFILE))
  1823. &&(Write(MonatDatei,Monat,JAHRLENG) != DISKERROR)))
  1824.     Disk_Fehler(NebenWindow);
  1825. else
  1826.     {
  1827.     MonGeaendert = FALSE;
  1828.     Ok = TRUE;
  1829.     }
  1830. if(MonatDatei)
  1831.     Close(MonatDatei);
  1832. Set_Screen_Title(MONAWIND,MONATITEL);
  1833. return(Ok);
  1834. }
  1835.  
  1836. /*********************************************************************/
  1837.  
  1838. VOID Mon_MausAbfrage()
  1839. {
  1840. VOID Aktiviere_MonZeile();
  1841.  
  1842. if(MessCode != SELECTUP)
  1843.     if(!(NebenWindow->MouseX < 11
  1844.     ||   NebenWindow->MouseX > 503
  1845.     ||   NebenWindow->MouseY < 35
  1846.     ||   NebenWindow->MouseY > 34+(AnzMonEin*9)))
  1847.         Aktiviere_MonZeile((NebenWindow->MouseY-35)/9);
  1848. return;
  1849. }
  1850.  
  1851. /*********************************************************************/
  1852.  
  1853. VOID Aktiviere_MonZeile(TempZeile)
  1854. SHORT TempZeile;
  1855. {
  1856. if(!(MonEinSel))
  1857.     {
  1858.     AktMonZeile = ((NebenWindow->MouseY)-35)/9;
  1859.     MonEinSel = TRUE;
  1860.     }
  1861. else
  1862.     {
  1863.     if(AktMonZeile == TempZeile)
  1864.         MonEinSel = FALSE;
  1865.     }
  1866. MonWahlBor.FrontPen = (MonEinSel) ? (UBYTE)RED : (UBYTE)GREY;
  1867. DrawBorder(Neben_rp,&MonWahlBor,9L,(LONG)33+(AktMonZeile*9));
  1868. return;
  1869. }
  1870.  
  1871. /*********************************************************************/
  1872.  
  1873. BOOL Open_MonGraphs()
  1874. {
  1875. BOOL Ok;
  1876.  
  1877. Window2.Screen = MainScreen;
  1878. if((Monat = (MONAT *) AllocMem(JAHRLENG,MEMF_PUBLIC|MEMF_CLEAR))
  1879. &&(NebenWindow = (struct Window*) OpenWindow(&Window2)))
  1880.     {
  1881.     Ok = TRUE;
  1882.     Set_Screen_Title(MONAWIND,MONATITEL);
  1883.     Neben_rp = NebenWindow->RPort;
  1884.     PolyDraw(Neben_rp,16L,RandNWind);
  1885.     PrintIText(Neben_rp,&UeberN,0L,0L);
  1886.     }
  1887. else
  1888.     {
  1889.     Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
  1890.     Ok = FALSE;
  1891.     }
  1892. return(Ok);
  1893. }
  1894.  
  1895. /*********************************************************************/
  1896.  
  1897. BOOL Open_MonatDat()
  1898. {
  1899. BOOL Ok = TRUE;
  1900. struct FileHandle *MonatDatei;
  1901.  
  1902. MonGeaendert = FALSE;
  1903. Set_Screen_Title(MONAWIND,WORKTITEL);
  1904. if(!((MonatDatei = Open(MonatName,MODE_READWRITE))
  1905. &&(Read(MonatDatei,Monat,JAHRLENG) != DISKERROR)))
  1906.     {
  1907.     Ok = FALSE;
  1908.     Disk_Fehler(NebenWindow);
  1909.     }
  1910. if(MonatDatei)
  1911.     Close(MonatDatei);
  1912. Set_Screen_Title(MONAWIND,MONATITEL);
  1913. return(Ok);
  1914. }
  1915.  
  1916. /*********************************************************************/
  1917.  
  1918. VOID Print_Monat(Welchen)
  1919. USHORT Welchen;
  1920. {
  1921. MONAT    *mon = Monat+(Welchen*MONEINT);
  1922. STRPTR    dat = Datum();
  1923.  
  1924. AnzMonEin = 0;
  1925. SetAPen(Neben_rp,GREY);
  1926. RectFill(Neben_rp,7L,28L,503L,227L);
  1927. LoeschFeld(Neben_rp,588L,22L,3);
  1928. Print(Neben_rp,&NameMonat[Welchen][0],588L,22L,RED);
  1929. while((*(mon->Bezeichnung) != '\0') && (AnzMonEin < MONEINT))
  1930.     {
  1931.     sprintf(TempTextGr,"01.%02u.%2s     %-33s      %9.2f",
  1932.         Welchen+1,(dat+6),mon,mon->Betrag);
  1933.     Print(Neben_rp,TempTextGr,xDatum,(LONG)40+(9*AnzMonEin),BLUE);
  1934.     mon++;
  1935.     AnzMonEin++;
  1936.     }
  1937. return;
  1938. }
  1939.  
  1940. /*********************************************************************/
  1941.  
  1942. MONAT** Find_Pointer(Sprung)
  1943. SHORT Sprung;
  1944. {
  1945. UCOUNT        i;
  1946. USHORT        j = AktMonat;
  1947. static    MONAT    *MonPoint[12];
  1948.  
  1949. for(i=0;i<(12/Sprung);i++,j+=Sprung)
  1950.     {
  1951.     if(j > 11)
  1952.         j-=12;
  1953.     MonPoint[i] = Monat+(MONEINT*j);
  1954.     }
  1955. return(&MonPoint[0]);
  1956. }
  1957.  
  1958. /*********************************************************************/
  1959.  
  1960. VOID End_Monat()
  1961. {
  1962. if(Monat)
  1963.     FreeMem(Monat,JAHRLENG);
  1964. if(NebenWindow)
  1965.     CloseWindow(NebenWindow);
  1966. return;
  1967. }
  1968.  
  1969. /*********************************************************************/
  1970.  
  1971. VOID EndProgramm(Fehler)
  1972. int Fehler;
  1973. {
  1974. UCOUNT i;
  1975.  
  1976. if ((Fehler) && (IntuitionBase) && (TempText))
  1977.     {
  1978.     sprintf(TempText,"GiroManager FATAL-ERROR: %03d",Fehler);
  1979.     End.IText=TempText;
  1980.     AutoRequest(NULL,&End,&Cancel,&Cancel,NULL,NULL,274L,60L);
  1981.     }
  1982. if(HauptDatei)        Close(HauptDatei);
  1983. if(Index)        FreeMem(Index,INDEXLENG);
  1984. if(Eintrag)        FreeMem(Eintrag,SIZEEINTRAG*20);
  1985. if(UndoBuffer)        FreeMem(UndoBuffer,50L);
  1986. if(TempText)        FreeMem(TempText,50L);
  1987. if(TempTextGr)        FreeMem(TempTextGr,100L);
  1988.  
  1989. for(i=0;i<3;i++)
  1990.     if(EingabeBuffer[i])
  1991.             FreeMem(EingabeBuffer[i],34L);
  1992. for(i=0;i<3;i++)
  1993.     if(SuchBuffer[i])
  1994.             FreeMem(SuchBuffer[i],34L);
  1995. for(i=0;i<3;i++)
  1996.     if(MonatBuffer[i])
  1997.             FreeMem(MonatBuffer[i],34L);
  1998. if(MainWindow)
  1999.     {
  2000.     ClearMenuStrip(MainWindow);
  2001.     CloseWindow(MainWindow);
  2002.     }
  2003. if(MainScreen)         CloseScreen(MainScreen);
  2004. if(GfxBase)         CloseLibrary(GfxBase);
  2005. if(IntuitionBase)     CloseLibrary(IntuitionBase);
  2006. exit(Fehler);
  2007. }
  2008.  
  2009. /*********************************************************************/
  2010. /*********************************************************************/
  2011. /*********************************************************************/
  2012.  
  2013.